home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / octa209s.zip / octave-2.09 / liboctave / file-ops.cc < prev    next >
C/C++ Source or Header  |  1997-08-20  |  7KB  |  384 lines
  1. /*
  2.  
  3. Copyright (C) 1996 John W. Eaton
  4.  
  5. This file is part of Octave.
  6.  
  7. Octave is free software; you can redistribute it and/or modify it
  8. under the terms of the GNU General Public License as published by the
  9. Free Software Foundation; either version 2, or (at your option) any
  10. later version.
  11.  
  12. Octave is distributed in the hope that it will be useful, but WITHOUT
  13. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15. for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with Octave; see the file COPYING.  If not, write to the Free
  19. Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20.  
  21. */
  22.  
  23. /* Modified by Klaus Gebhardt, 1996 */
  24.  
  25. #ifdef HAVE_CONFIG_H
  26. #include <config.h>
  27. #endif
  28.  
  29. #include <cerrno>
  30. #include <cstdio>
  31. #include <cstdlib>
  32. #include <cstring>
  33.  
  34. #ifdef HAVE_UNISTD_H
  35. #ifdef HAVE_SYS_TYPES_H
  36. #include <sys/types.h>
  37. #endif
  38. #include <unistd.h>
  39. #endif
  40.  
  41. #ifdef __EMX__
  42. #include <mkfifo.h>
  43. #endif
  44.  
  45. #include "file-ops.h"
  46. #include "lo-error.h"
  47. #include "statdefs.h"
  48.  
  49. // These must come after <sys/types.h> and <sys/stat.h>.
  50.  
  51. #include <safe-lstat.h>
  52. #include <safe-stat.h>
  53.  
  54. // XXX FIXME XXX -- the is_* and mode_as_string functions are only valid
  55. // for initialized objects.  If called for an object that is not
  56. // initialized, they should throw an exception.
  57.  
  58. bool
  59. file_stat::is_blk (void) const
  60. {
  61. #ifdef S_ISBLK
  62.   return S_ISBLK (fs_mode);
  63. #else
  64.   return false;
  65. #endif
  66. }
  67.  
  68. bool
  69. file_stat::is_chr (void) const
  70. {
  71. #ifdef S_ISCHR
  72.   return S_ISCHR (fs_mode);
  73. #else
  74.   return false;
  75. #endif
  76. }
  77.  
  78. bool
  79. file_stat::is_dir (void) const
  80. { 
  81. #ifdef S_ISDIR
  82.   return S_ISDIR (fs_mode);
  83. #else
  84.   return false;
  85. #endif
  86. }
  87.  
  88. bool
  89. file_stat::is_fifo (void) const
  90. { 
  91. #ifdef S_ISFIFO
  92.   return S_ISFIFO (fs_mode);
  93. #else
  94.   return false;
  95. #endif
  96. }
  97.  
  98. bool
  99. file_stat::is_lnk (void) const
  100. { 
  101. #ifdef S_ISLNK
  102.   return S_ISLNK (fs_mode);
  103. #else
  104.   return false;
  105. #endif
  106. }
  107.  
  108. bool
  109. file_stat::is_reg (void) const
  110. { 
  111. #ifdef S_ISREG
  112.   return S_ISREG (fs_mode);
  113. #else
  114.   return false;
  115. #endif
  116. }
  117.  
  118. bool
  119. file_stat::is_sock (void) const
  120. { 
  121. #ifdef S_ISSOCK
  122.   return S_ISSOCK (fs_mode);
  123. #else
  124.   return false;
  125. #endif
  126. }
  127.  
  128. extern "C" void mode_string ();
  129.  
  130. string
  131. file_stat::mode_as_string (void) const
  132. {
  133.   char buf[11];
  134.  
  135.   mode_string (fs_mode, buf);
  136.  
  137.   buf[10] = '\0';
  138.  
  139.   return string (buf);
  140. }
  141.  
  142. // Private stuff:
  143.  
  144. void
  145. file_stat::update_internal (bool force)
  146. {
  147.   if (! initialized || force)
  148.     {
  149.       initialized = false;
  150.       fail = false;
  151.  
  152.       const char *cname = file_name.c_str ();
  153.  
  154.       struct stat buf;
  155.  
  156.       int status = follow_links
  157.     ? SAFE_STAT (cname, &buf) : SAFE_LSTAT (cname, &buf);
  158.  
  159.       if (status < 0)
  160.     {
  161.       fail = true;
  162.       errmsg = strerror (errno);
  163.     }
  164.       else
  165.     {
  166.       fs_mode = buf.st_mode;
  167.       fs_ino = buf.st_ino;
  168.       fs_dev = buf.st_dev;
  169.       fs_nlink = buf.st_nlink;
  170.       fs_uid = buf.st_uid;
  171.       fs_gid = buf.st_gid;
  172.       fs_size = buf.st_size;
  173.       fs_atime = buf.st_atime;
  174.       fs_mtime = buf.st_mtime;
  175.       fs_ctime = buf.st_ctime;
  176.  
  177. #if defined (HAVE_ST_RDEV)
  178.       fs_rdev = buf.st_rdev;
  179. #endif
  180.  
  181. #if defined (HAVE_ST_BLKSIZE)
  182.       fs_blksize = buf.st_blksize;
  183. #endif
  184.  
  185. #if defined (HAVE_ST_BLOCKS)
  186.       fs_blocks = buf.st_blocks;
  187. #endif
  188.     }
  189.  
  190.       initialized = true;
  191.     }
  192. }
  193.  
  194. void
  195. file_stat::copy (const file_stat& fs)
  196. {
  197.   file_name = fs.file_name;
  198.   follow_links = fs.follow_links;
  199.   initialized = fs.initialized;
  200.   fail = fs.fail;
  201.   errmsg = fs.errmsg;
  202.   fs_mode = fs.fs_mode;
  203.   fs_ino = fs.fs_ino;
  204.   fs_dev = fs.fs_dev;
  205.   fs_nlink = fs.fs_nlink;
  206.   fs_uid = fs.fs_uid;
  207.   fs_gid = fs.fs_gid;
  208.   fs_size = fs.fs_size;
  209.   fs_atime = fs.fs_atime;
  210.   fs_mtime = fs.fs_mtime;
  211.   fs_ctime = fs.fs_ctime;
  212.  
  213. #if defined (HAVE_ST_RDEV)
  214.   fs_rdev = fs.fs_rdev;
  215. #endif
  216.  
  217. #if defined (HAVE_ST_BLKSIZE)
  218.   fs_blksize = fs.fs_blksize;
  219. #endif
  220.  
  221. #if defined (HAVE_ST_BLOCKS)
  222.   fs_blocks = fs.fs_blocks;
  223. #endif
  224. }
  225.  
  226. // Functions for octave.
  227.  
  228. // Has FILE been modified since TIME?  Returns 1 for yes, 0 for no,
  229. // and -1 for any error.
  230. int
  231. is_newer (const string& file, time_t time)
  232. {
  233.   file_stat fs (file);
  234.  
  235.   return fs ? fs.is_newer (time) : -1;
  236. }
  237.  
  238. // We provide a replacement for mkdir().
  239.  
  240. int
  241. oct_mkdir (const string& name, mode_t mode)
  242. {
  243.   return mkdir (name.c_str (), mode);
  244. }
  245.  
  246. int
  247. oct_mkdir (const string& name, mode_t mode, string& msg)
  248. {
  249.   msg = string ();
  250.  
  251.   int status = mkdir (name.c_str (), mode);
  252.  
  253.   if (status < 0)
  254.     msg = strerror (errno);
  255.  
  256.   return status;
  257. }
  258.  
  259. // I don't know how to emulate this on systems that don't provide it.
  260.  
  261. int
  262. oct_mkfifo (const string& name, mode_t mode)
  263. {
  264.   string msg;
  265.   return oct_mkfifo (name, mode, msg);
  266. }
  267.  
  268. int
  269. oct_mkfifo (const string& name, mode_t mode, string& msg)
  270. {
  271.   msg = string ();
  272.  
  273. #if defined (HAVE_MKFIFO)
  274.   int status = mkfifo (name.c_str (), mode);
  275.  
  276.   if (status < 0)
  277.     msg = strerror (errno);
  278.  
  279.   return status;
  280. #else
  281.   msg = "mkfifo: not implemented on this system";
  282.   return -1;
  283. #endif
  284. }
  285.  
  286. // We provide a replacement for rename().
  287.  
  288. int
  289. oct_rename (const string& from, const string& to)
  290. {
  291.   return rename (from.c_str (), to.c_str ());
  292. }
  293.  
  294. int
  295. oct_rename (const string& from, const string& to, string& msg)
  296. {
  297.   msg = string ();
  298.  
  299.   int status = rename (from.c_str (), to.c_str ());
  300.  
  301.   if (status < 0)
  302.     msg = strerror (errno);
  303.  
  304.   return status;
  305. }
  306.  
  307. // We provide a replacement for rmdir().
  308.  
  309. int
  310. oct_rmdir (const string& name)
  311. {
  312.   return rmdir (name.c_str ());
  313. }
  314.  
  315. int
  316. oct_rmdir (const string& name, string& msg)
  317. {
  318.   msg = string ();
  319.  
  320.   int status = rmdir (name.c_str ());
  321.  
  322.   if (status < 0)
  323.     msg = strerror (errno);
  324.  
  325.   return status;
  326. }
  327.  
  328. // We provide a replacement for tempnam().
  329.  
  330. string
  331. oct_tempnam (void)
  332. {
  333.   string retval;
  334.  
  335.   char *tmp = tempnam (0, "oct-");
  336.  
  337.   if (tmp)
  338.     {
  339.       retval = tmp;
  340.  
  341.       free (tmp);
  342.     }
  343.   else
  344.     (*current_liboctave_error_handler) ("can't open temporary file!");
  345.  
  346.   return retval;
  347. }
  348.  
  349.  
  350. int
  351. oct_umask (mode_t mode)
  352. {
  353. #if defined (HAVE_UMASK)
  354.   return umask (mode);
  355. #else
  356.   return 0;
  357. #endif
  358. }
  359.  
  360. int
  361. oct_unlink (const string& name)
  362. {
  363.   return unlink (name.c_str ());
  364. }
  365.  
  366. int
  367. oct_unlink (const string& name, string& errmsg)
  368. {
  369.   errmsg = string ();
  370.  
  371.   int status = unlink (name.c_str ());
  372.  
  373.   if (status < 0)
  374.     errmsg = strerror (errno);
  375.  
  376.   return status;
  377. }
  378.  
  379. /*
  380. ;;; Local Variables: ***
  381. ;;; mode: C++ ***
  382. ;;; End: ***
  383. */
  384.